<!-- <script>
    /* promise 用来管理异步编程代码，避免回调地狱(回调嵌套回调) -> '承诺者设置模式'
       ajax 串行&并行 ： 多个ajax请求模式管理
       串行 ： 一般多个请求之间存在依赖 （当前请求需要用到上一个请求获取结果），此时我们只能等待上一个请求成功，才能发送下一个
       并行 ： 多个请求没有依赖，可以同时发送，谁先请求回来，先处理谁
    */
    // // 回调函数 ： 异步ajax 请求
    const queryAPI1 = (callback) => {
        setTimeout(() => {
           let result = 1;
           callback(result)
        },2000)
    };
    queryAPI1((result)=>{
         console.log('请求成功',result);
    });
    console.log(
        'ok'
    );
    
    // 语法糖  实现串行
    (async ()=>{
        let result = await queryAPI1()

        result = await queryAPI2()
    });
</script> -->
<!-- <script src="#">
    /* 语法 let 实例对象 = new promise([executor]) 
    [executor]必须传递一个函数
    [executor]函数执行是同步的 在new promise立即执行
     pormise 内部在执行此函数时，会给函数传递实参值，我们基于reslove/reject 形参获取这个值
       reslove,reject 存储的值是小函数，后期把相应的函数执行，会修改实例的状态和值

          私有属性
       [[PromiseState]]: "pending"  实例状态 pending 准备，fulfilled 成功 ，rejected 失败
       [[PromiseResult]]: undefined 实例的值
          promise.prototype 共有属性方法
        then
        catch           p.catch([onrejected]) === p.then(null,[onrejected])  失败执行
        finally         无论成功还是失败都执行里面函数
        Symbol.toStringTa:"Promise"
    */
    let p = new Promise((reslove,reject)=>{
        console.log(reslove,reject);
        // 状态为pending改为fulfilled或者rejected，则不能修改了
        reslove(100); // 把实例状态修改为fulfilled ，值是100
        reject(0); // 把实例状态修改为rejected ，值是0
        // 如果executor函数执行报错，实例状态为rejected，值为报错原因
    });
    /*pormise实例.then([onfulfilled],[onrejected])
      根据我们实例的状态决定执行哪个函数
       如果实例是pending，则暂时都不执行
       把实际值传递给相关函数，所以value/reason获取的就是当前实例的值
       ！同一个实例可以多次调用then方法（不常见）
    */
       p.then (
        // onfulfilled 实例状态为成功
        (value) => {
            console.log("成功",value);
        },
        // onrejected 失败
        (reason) => {
            console.log("失败",reason);
        }
       )
    console.log(p);
</script>  -->
<script src="">
    let p = new Promise((reslove,reject) => {
          // executor函数中用来管理异步代码 ，当异步操作成功，基于reslove/reject修改实例状态，决定then中传递的函数该执行哪一个
          setTimeout(() => {
             reslove(100);
          },2000)
    });
    p.then(value => {
       console.log("成功",value);
    },reason => {
       console.log("失败",reason);
    })

    
    
    //2. Promise.resolve(100).then(value => {},reason => {}) 创建一个实例状态为成功，值是100
    // Promise.reject(0)  创建一个状态是失败，值为0

    // 3. let p2 = p1.then()
      // 每一次执行then方法，p1的状态会决定onfulfilled/onrejected谁执行。也会创建一个全新的实例p2
      // 如何修改p2的状态和值
        // 由onfulfilled/onrejected决定新实例p2的状态和值
        // + 函数执行是否报错  没报错则看函数执行和返回值
        // + 没有返回值,则p2状态为成功，值是undefine
        // + 返回值是另一个pormise实例 ， 则新实例的状态和值决定了p2的状态和值

        /* 这种机制可以保证一直.then下去 ，我们称为“then链机制”
        then链具备“穿透”/“顺延”性
           onfulfilled/onrejected可以不传递  
           .then() 如果不传递，则顺延到下一个同等方法的执行方法上！  
           原理： 我们不设置onfulfilled/onrejected，在promise内部会帮我们设置默认值
           默认加的函数可以保证状态和值的顺延
           */
          // 真实项目中一般只传递.then(onfulfilled),在末尾设置.catch(onrejected)
          // ！好处：then只处理状态为成功要做的事情，不论在何时遇到失败的实例都会顺延到.catch
</script> 